package com.aizuda.boot.modules.business.contract.mapper;

import com.aizuda.boot.modules.business.contract.entity.ContractEntity;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import java.util.List;
import java.util.Map;

/**
 * mapper接口
 */
@Mapper
public interface ContractMapper extends BaseMapper<ContractEntity> {

    /**
     * 根据查询类型查询合同列表
     *
     * @param queryType
     * @param userId
     * @param handlerFieldId
     * @return
     */
    @Select("<script>" +
            "SELECT c.* FROM contract c " +
            "<if test='queryType == 1 || queryType == 2'>" +
            "INNER JOIN contract_field_value cfv ON c.id = cfv.contract_id " +
            "AND cfv.field_id = #{handlerFieldId} " +
            "AND cfv.field_value = #{userId} " +
            "</if>" +
            "<where>" +
            "   AND (c.is_matched IS NULL OR c.is_matched != 1)" +
            "   <if test='queryType == 2'>" +
            "       AND c.current_status = 'DRAFT'" +
            "   </if>" +
            "</where>" +
            "</script>")
    List<ContractEntity> selectContractsByQueryType(@Param("queryType") Integer queryType,
                                                    @Param("userId") Long userId,
                                                    @Param("handlerFieldId") Long handlerFieldId);

    /**
     * 查询用户的历史任务
     *
     * @param actorId 用户ID
     * @return 历史任务列表
     */
    @Select("SELECT hta.task_id, hta.instance_id, hta.actor_id, ht.task_name, ht.create_time, ht.finish_time " +
            "FROM flw_his_task_actor hta " +
            "LEFT JOIN flw_his_task ht ON hta.task_id = ht.id " +
            "WHERE hta.actor_type = 0 AND hta.actor_id = #{actorId} AND ht.task_type != 2")
    List<Map<String, Object>> selectHistoryTaskActors(@Param("actorId") String actorId);

    /**
     * 查询历史流程实例（优先查询历史表）
     *
     * @param instanceId 实例ID
     * @return 历史实例信息
     */
    @Select("SELECT process_id, id as instance_id, current_node_name, instance_state FROM flw_his_instance WHERE id = #{instanceId}")
    Map<String, Object> selectHistoryInstance(@Param("instanceId") Long instanceId);

    /**
     * 查询当前流程实例（设置为进行中状态，不会被过滤）
     *
     * @param instanceId 实例ID
     * @return 当前实例信息
     */
    @Select("SELECT process_id, id as instance_id, current_node_name, 999 as instance_state FROM flw_instance WHERE id = #{instanceId}")
    Map<String, Object> selectCurrentInstance(@Param("instanceId") Long instanceId);

    /**
     * 查询历史任务
     *
     * @param taskId 任务ID
     * @return 历史任务信息
     */
    @Select("SELECT task_name, create_time FROM flw_his_task WHERE id = #{taskId} " +
            "UNION ALL " +
            "SELECT task_name, create_time FROM flw_task WHERE id = #{taskId}")
    Map<String, Object> selectHistoryTask(@Param("taskId") Long taskId);

    /**
     * 查询用户的抄送任务（包括当前和历史）
     *
     * @param actorId 用户ID
     * @return 抄送任务列表
     */
    @Select("SELECT instance_id, task_id FROM flw_task_actor " +
            "WHERE actor_type = 0 AND actor_id = #{actorId} " +
            "AND task_id IN (SELECT id FROM flw_task WHERE task_type = 2) " +
            "UNION ALL " +
            "SELECT instance_id, task_id FROM flw_his_task_actor " +
            "WHERE actor_type = 0 AND actor_id = #{actorId} " +
            "AND task_id IN (SELECT id FROM flw_his_task WHERE task_type = 2)")
    List<Map<String, Object>> selectCcTaskActors(@Param("actorId") String actorId);

    /**
     * 获取交易方名称（子查询）
     */
    String selectOtherPartName(@Param("contractId") Long contractId);

    /**
     * 获取我方名称（法人实体名称）
     */
    String selectOurPartyName(@Param("contractId") Long contractId);

    /**
     * 获取合同金额（子查询）
     */
    Double selectContractAmount(@Param("contractId") Long contractId);

    /**
     * 查询实例信息及其流程类型
     */
    @Select("<script>" +
            "SELECT i.id as instance_id, i.business_key, p.process_type " +
            "FROM flw_instance i " +
            "LEFT JOIN flw_process p ON i.process_id = p.id " +
            "WHERE i.id IN " +
            "<foreach collection='instanceIds' item='id' open='(' separator=',' close=')'>" +
            "#{id}" +
            "</foreach>" +
            "UNION ALL " +
            "SELECT hi.id as instance_id, hi.business_key, p.process_type " +
            "FROM flw_his_instance hi " +
            "LEFT JOIN flw_process p ON hi.process_id = p.id " +
            "WHERE hi.id IN " +
            "<foreach collection='instanceIds' item='id' open='(' separator=',' close=')'>" +
            "#{id}" +
            "</foreach>" +
            "</script>")
    List<Map<String, Object>> selectInstancesWithProcessType(@Param("instanceIds") List<Long> instanceIds);

    // ==================== 优化查询方法 ====================
    
    /**
     * 批量查询我申请的合同（优化版）
     */
    List<Map<String, Object>> selectMyAppliedContractsOptimized(@Param("userId") Long userId, 
                                                               @Param("tenantKeys") List<String> tenantKeys);

    /**
     * 批量查询我已审批的合同（优化版）
     */
    List<Map<String, Object>> selectMyApprovedContractsOptimized(@Param("userId") Long userId,
                                                                @Param("tenantKeys") List<String> tenantKeys);

    /**
     * 批量查询我待审批的合同（优化版）
     */
    List<Map<String, Object>> selectMyPendingContractsOptimized(@Param("userId") Long userId,
                                                               @Param("tenantKeys") List<String> tenantKeys);

    /**
     * 批量查询我提交的待审批合同（优化版）
     */
    List<Map<String, Object>> selectMyAppliedPendingContractsOptimized(@Param("userId") Long userId,
                                                                      @Param("tenantKeys") List<String> tenantKeys);

    /**
     * 批量查询合同的字段值信息
     */
    List<Map<String, Object>> selectContractFieldValuesBatch(@Param("contractIds") List<Integer> contractIds);

    /**
     * 批量查询合同类型名称
     */
    List<Map<String, Object>> selectContractTypeNamesBatch(@Param("contractIds") List<Integer> contractIds);

    /**
     * 批量查询合同类型层级名称（递归查询所有父级）
     */
    List<Map<String, Object>> selectContractTypeHierarchiesBatch(@Param("contractIds") List<Integer> contractIds);

    /**
     * 批量查询交易方详细信息（COUNTERPART_PEER字段）
     */
    List<Map<String, Object>> selectCounterpartPeerDetailsBatch(@Param("contractIds") List<Integer> contractIds);

    /**
     * 批量查询法人实体详细信息（COUNTERPART_SELF字段）
     */
    List<Map<String, Object>> selectCounterpartSelfDetailsBatch(@Param("contractIds") List<Integer> contractIds);

    /**
     * 查询启用的模块信息
     */
    List<Map<String, Object>> selectEnabledModules();

    /**
     * 批量查询法人实体和交易方信息
     */
    List<Map<String, Object>> selectLegalEntityAndCounterpartyBatch(@Param("contractIds") List<Integer> contractIds);

    /**
     * 批量查询主合同文件信息
     */
    List<Map<String, Object>> selectMainContractFilesBatch(@Param("contractIds") List<Integer> contractIds);

    /**
     * 批量查询申请人部门信息
     */
    List<Map<String, Object>> selectApplicantDepartmentsBatch(@Param("contractIds") List<Integer> contractIds);

    // ==================== 性能优化查询方法 ====================
    
    /**
     * 优化的待审批任务查询 - 使用JOIN替代循环查询
     * @param userId 用户ID
     * @param tenantKeys 租户权限列表
     * @return 待审批任务列表
     */
    List<Map<String, Object>> selectPendingTasksOptimized(@Param("userId") String userId, 
                                                          @Param("tenantKeys") List<String> tenantKeys);

    /**
     * 优化的已处理任务查询 - 使用JOIN替代多次查询
     * @param userId 用户ID
     * @param tenantKeys 租户权限列表
     * @return 已处理任务列表
     */
    List<Map<String, Object>> selectProcessedTasksOptimized(@Param("userId") String userId, 
                                                           @Param("tenantKeys") List<String> tenantKeys);

    /**
     * 优化的抄送任务查询 - 直接查询避免流程引擎API调用
     * @param userId 用户ID
     * @param tenantKeys 租户权限列表
     * @return 抄送任务列表
     */
    List<Map<String, Object>> selectCcTasksOptimized(@Param("userId") String userId, 
                                                    @Param("tenantKeys") List<String> tenantKeys);

    /**
     * 优化的到期合同查询 - 直接在数据库层面筛选到期合同
     * @param userId 用户ID
     * @param tenantKeys 租户权限列表
     * @param startDate 开始日期
     * @param endDate 结束日期
     * @return 到期合同数量
     */
    Long selectExpiringContractCountOptimized(@Param("userId") Long userId,
                                             @Param("tenantKeys") List<String> tenantKeys,
                                             @Param("startDate") String startDate,
                                             @Param("endDate") String endDate);

    /**
     * 高性能模糊搜索合同 - 支持合同名称、合同编号、申请人姓名的模糊匹配
     * @param tenantKeys 租户权限列表
     * @param statusList 合同状态列表
     * @param fuzzyKeyword 模糊搜索关键字
     * @param userId 用户ID（可选，用于过滤申请人）
     * @return 匹配的合同列表
     */
    List<Map<String, Object>> selectContractsWithFuzzySearch(@Param("tenantKeys") List<String> tenantKeys,
                                                            @Param("statusList") List<String> statusList,
                                                            @Param("fuzzyKeyword") String fuzzyKeyword,
                                                            @Param("userId") Long userId);

}
